import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:permission_handler/permission_handler.dart';
import '../../../common/models/index.dart';
import '../../../common/api/user_api.dart';
import '../../../common/services/index.dart';
import '../../../common/utils/loading_util.dart';  // 🔥 使用 LoadingUtil
import '../../../common/components/image_picker_bottom_sheet.dart';
import '../../../common/routers/index.dart';

/// 活动发布控制器
/// 
/// 功能特点：
/// - 使用企业级 Form 模型管理表单状态
/// - 集成高德定位服务，自动获取位置
/// - 支持地图选择位置
/// - 智能时间选择验证（最短30分钟，最长7天）
/// - 异步图片上传（选择后自动上传）
/// - 完整的表单验证
/// - 发布成功后跳转到"我的发布"标签页
class ActivitePubilshController extends GetxController {
  // ==================== 核心：使用 Form 模型 ====================
  
  /// 活动发布表单模型
  late final Rx<ActivityPublishForm> form;
  
  // ==================== 服务依赖 ====================
  
  /// 用户服务
  UserService get _userService => UserService.to;
  
  /// 🔥 高德定位服务
  AmapLocationService get _amapLocationService => Get.find<AmapLocationService>();
  
  // ==================== 响应式状态 ====================
  
  /// 加载状态
  RxBool isLoading = false.obs;
  
  /// 图片上传状态
  RxBool isUploadingImage = false.obs;
  
  /// 定位加载状态
  RxBool isLocationLoading = false.obs;
  
  // ==================== TextEditingController ====================
  
  final TextEditingController titleController = TextEditingController();
  final FocusNode titleFocusNode = FocusNode();
  
  final TextEditingController peopleCountController = TextEditingController();
  final FocusNode peopleCountFocusNode = FocusNode();
  
  final TextEditingController detailsController = TextEditingController();
  final FocusNode detailsFocusNode = FocusNode();
  
  // ==================== 常量选项 ====================
  
  final List<String> limitOptions = ['无限制', '男', '女'];
  final List<String> paymentOptions = ['我买单', 'AA', '双方商议'];
  
  // ==================== 初始化 ====================
  
  @override
  void onInit() {
    super.onInit();
    _initForm();
    _initTextControllerListeners();
    _autoLocationCheck();
  }
  
  /// 初始化表单模型
  void _initForm() {
    form = ActivityPublishForm().obs;
    debugPrint('✅ ActivityPublishForm 初始化完成');
  }
  
  /// 初始化文本控制器监听
  void _initTextControllerListeners() {
    // 标题变化同步到 Form
    titleController.addListener(() {
      form.value.title = titleController.text;
      form.refresh();
    });
    
    // 人数变化同步到 Form
    peopleCountController.addListener(() {
      form.value.peopleCount = peopleCountController.text;
      form.refresh();
    });
    
    // 详情变化同步到 Form
    detailsController.addListener(() {
      form.value.details = detailsController.text;
      form.refresh();
    });
  }
  
  /// 自动检查位置权限并定位
  Future<void> _autoLocationCheck() async {
    try {
      isLocationLoading.value = true;
      form.value.location = '正在定位中...';
      form.refresh();
      
      debugPrint('📍 开始自动定位...');
      
      // 🔥 使用AmapLocationService获取当前位置
      if (_amapLocationService.isSuccess) {
        // 如果已经定位成功，直接使用缓存的位置
        debugPrint('✅ 使用已缓存的位置');
        form.value.location = _amapLocationService.locationText;
        form.value.latitude = _amapLocationService.latitude;
        form.value.longitude = _amapLocationService.longitude;
        form.value.isDefaultLocation = !_amapLocationService.isSuccess;
        form.refresh();
      } else {
        // 如果还没定位，执行智能定位
        debugPrint('🎯 执行智能定位...');
        
        // 🔥 智能判断是否显示权限说明：
        // - 如果是首次请求权限（denied状态），显示权限说明
        // - 如果已授权或已拒绝，静默检查
        final currentStatus = await Permission.location.status;
        final showRationale = currentStatus == PermissionStatus.denied;
        
        debugPrint('📍 当前权限状态: $currentStatus');
        debugPrint('📍 是否显示权限说明: $showRationale');
        
        final success = await _amapLocationService.smartLocation(
          showRationale: showRationale,  // 🔥 首次请求显示说明，后续静默
        );
        
        if (success) {
          debugPrint('✅ 定位成功');
          form.value.location = _amapLocationService.locationText;
          form.value.latitude = _amapLocationService.latitude;
          form.value.longitude = _amapLocationService.longitude;
          form.value.isDefaultLocation = false;
          form.refresh();
        } else {
          debugPrint('⚠️ 定位失败，使用默认位置');
          _setDefaultLocation();
        }
      }
      
    } catch (e) {
      debugPrint('❌ 自动定位异常: $e');
      _setDefaultLocation();
    } finally {
      isLocationLoading.value = false;
    }
  }
  
  /// 设置默认位置
  void _setDefaultLocation() {
    form.value.location = '山东省烟台市莱山区';
    form.value.latitude = 37.463822;
    form.value.longitude = 121.447935;
    form.value.isDefaultLocation = true;
    form.refresh();
    debugPrint('🏠 使用默认位置');
  }
  
  /// 刷新位置（重新定位）
  Future<void> refreshLocation() async {
    if (isLocationLoading.value) return;
    await _autoLocationCheck();
  }
  
  /// 🗺️ 打开地图选择位置
  Future<void> openMapForLocation() async {
    clearAllFocus();
    await Future.delayed(const Duration(milliseconds: 150));
    
    try {
      debugPrint('🗺️ 打开地图选择位置...');
      
      // 跳转到地图页面
      final result = await Get.toNamed(RouteNames.systemAmap);
      
      debugPrint('🔙 从地图页面返回，结果: $result');
      
      // 处理返回的位置数据
      if (result != null && result is Map<String, dynamic>) {
        updateLocationFromMap(result);
      } else {
        debugPrint('ℹ️ 用户未选择位置');
      }
    } catch (e) {
      debugPrint('❌ 打开地图异常: $e');
      LoadingUtil.error('打开地图失败');  // 🔥 使用 LoadingUtil
    }
  }
  
  /// 从地图页面更新位置信息
  void updateLocationFromMap(Map<String, dynamic> locationData) {
    try {
      final address = locationData['address'] as String?;
      final lat = locationData['latitude'] as double?;
      final lng = locationData['longitude'] as double?;
      
      if (address != null && lat != null && lng != null) {
        form.value.location = address;
        form.value.latitude = lat;
        form.value.longitude = lng;
        form.value.isDefaultLocation = false;
        form.refresh();
        
        LoadingUtil.toast('位置更新成功');  // 🔥 使用 LoadingUtil（轻提示）
        debugPrint('✅ 位置信息更新: $address ($lat, $lng)');
      } else {
        debugPrint('⚠️ 位置数据不完整');
        LoadingUtil.info('位置数据不完整');  // 🔥 使用 LoadingUtil
      }
    } catch (e) {
      debugPrint('❌ 处理地图位置数据异常: $e');
      LoadingUtil.error('位置数据处理失败');  // 🔥 使用 LoadingUtil
    }
  }
  
  // ==================== 表单操作 ====================
  
  /// 清除所有输入框焦点
  void clearAllFocus() {
    titleFocusNode.unfocus();
    peopleCountFocusNode.unfocus();
    detailsFocusNode.unfocus();
    
    if (Get.context != null) {
      FocusScope.of(Get.context!).unfocus();
    }
  }
  
  /// 打开日期时间选择器
  Future<void> openDateTimePicker(BuildContext context, bool isStartDate) async {
    clearAllFocus();
    await Future.delayed(const Duration(milliseconds: 150));
    
    // 确定最小时间、最大时间和初始时间
    DateTime minTime;
    DateTime maxTime;
    DateTime initialTime;
    
    if (isStartDate) {
      // 🎯 开始时间：最早为当前时间，最晚为1年后
      minTime = DateTime.now();
      maxTime = DateTime.now().add(const Duration(days: 365));
      initialTime = form.value.startDate ?? DateTime.now();
      
      // 确保初始时间不早于最小时间
      if (initialTime.isBefore(minTime)) {
        initialTime = minTime;
      }
    } else {
      // 🎯 结束时间：最早为开始时间（如果已选择），最晚为开始时间+7天
      if (form.value.startDate == null) {
        LoadingUtil.info('请先选择开始时间');  // 🔥 使用 LoadingUtil
        return;
      }
      
      minTime = form.value.startDate!;
      maxTime = form.value.startDate!.add(const Duration(days: 7)); // 🎯 最长7天
      initialTime = form.value.endDate ?? minTime.add(const Duration(hours: 2));
      
      // 确保初始时间在有效范围内
      if (initialTime.isBefore(minTime)) {
        initialTime = minTime.add(const Duration(hours: 1));
      }
      if (initialTime.isAfter(maxTime)) {
        initialTime = maxTime;
      }
    }
    
    // 第一步：选择日期
    final DateTime? pickedDate = await showDatePicker(
      context: context,
      initialDate: initialTime,
      firstDate: minTime,
      lastDate: maxTime, // 🎯 应用最大时间限制
      locale: const Locale('zh', 'CN'),
      builder: (context, child) {
        return Theme(
          data: ThemeData.light().copyWith(
            primaryColor: const Color(0xFFE33641),
            colorScheme: const ColorScheme.light(
              primary: Color(0xFFE33641),
            ),
          ),
          child: child!,
        );
      },
    );
    
    if (pickedDate != null) {
      // 第二步：选择时间
      if (!context.mounted) return;
      
      final TimeOfDay? pickedTime = await showTimePicker(
        context: context,
        initialTime: TimeOfDay.fromDateTime(initialTime),
        builder: (context, child) {
          return Theme(
            data: ThemeData.light().copyWith(
              primaryColor: const Color(0xFFE33641),
              colorScheme: const ColorScheme.light(
                primary: Color(0xFFE33641),
              ),
            ),
            child: child!,
          );
        },
      );
      
      if (pickedTime != null) {
        // 组合日期和时间
        final DateTime finalDateTime = DateTime(
          pickedDate.year,
          pickedDate.month,
          pickedDate.day,
          pickedTime.hour,
          pickedTime.minute,
        );
        
        // 🎯 处理开始时间选择
        if (isStartDate) {
          // 检查开始时间不能早于当前时间
          if (finalDateTime.isBefore(DateTime.now())) {
            LoadingUtil.info('开始时间不能早于当前时间');  // 🔥 使用 LoadingUtil
            return;
          }
          
          form.value.startDate = finalDateTime;
          
          // 🎯 如果开始时间改变，需要检查并调整结束时间
          if (form.value.endDate != null) {
            // 如果结束时间早于新的开始时间，清空结束时间
            if (form.value.endDate!.isBefore(finalDateTime) || 
                form.value.endDate!.isAtSameMomentAs(finalDateTime)) {
              form.value.endDate = null;
              LoadingUtil.toast('开始时间已更新，请重新选择结束时间');  // 🔥 使用 LoadingUtil
            }
            // 如果结束时间距离新开始时间超过7天，清空结束时间
            else if (form.value.endDate!.difference(finalDateTime).inDays > 7) {
              form.value.endDate = null;
              LoadingUtil.toast('开始时间已更新，请重新选择结束时间（最长7天）');  // 🔥 使用 LoadingUtil
            }
          }
        } 
        // 🎯 处理结束时间选择
        else {
          if (form.value.startDate == null) {
            LoadingUtil.info('请先选择开始时间');  // 🔥 使用 LoadingUtil
            return;
          }
          
          final duration = finalDateTime.difference(form.value.startDate!);
          final durationMinutes = duration.inMinutes;
          final durationDays = duration.inMinutes / (60 * 24);
          
          // 验证1：结束时间必须大于开始时间
          if (finalDateTime.isBefore(form.value.startDate!) || 
              finalDateTime.isAtSameMomentAs(form.value.startDate!)) {
            LoadingUtil.info('结束时间必须大于开始时间');  // 🔥 使用 LoadingUtil
            return;
          }
          
          // 验证2：活动时长至少30分钟
          if (durationMinutes < 30) {
            LoadingUtil.info('活动时长至少需要30分钟');  // 🔥 使用 LoadingUtil
            return;
          }
          
          // 验证3：活动时长最多7天
          if (durationDays > 7) {
            LoadingUtil.info('活动时长最多7天');  // 🔥 使用 LoadingUtil
            return;
          }
          
          form.value.endDate = finalDateTime;
        }
        
        form.refresh();
      }
    }
  }
  
  /// 打开限制选择器
  Future<void> openLimitPicker(BuildContext context) async {
    clearAllFocus();
    await Future.delayed(const Duration(milliseconds: 150));
    
    await showModalBottomSheet(
      context: context,
      builder: (context) => Container(
        color: Colors.white,
        child: SafeArea(
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: limitOptions.map((option) => ListTile(
              title: Center(child: Text(option)),
              onTap: () {
                form.value.selectedLimit = option;
                form.refresh();
                Get.back();
              },
            )).toList(),
          ),
        ),
      ),
    );
  }
  
  /// 打开消费方式选择器
  Future<void> openPaymentPicker(BuildContext context) async {
    clearAllFocus();
    await Future.delayed(const Duration(milliseconds: 150));
    
    await showModalBottomSheet(
      context: context,
      builder: (context) => Container(
        color: Colors.white,
        child: SafeArea(
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: paymentOptions.map((option) => ListTile(
              title: Center(child: Text(option)),
              onTap: () {
                form.value.selectedPayment = option;
                form.refresh();
                Get.back();
              },
            )).toList(),
          ),
        ),
      ),
    );
  }
  
  // ==================== 图片操作 ====================
  
  /// 选择活动图片（使用统一的图片选择组件）
  Future<void> pickActivityImage() async {
    clearAllFocus();
    await Future.delayed(const Duration(milliseconds: 150));
    
    // 检查图片数量限制
    if (form.value.isImageLimitReached) {
      LoadingUtil.info('最多只能上传4张图片');  // 🔥 使用 LoadingUtil
      return;
    }
    
    // 使用统一的图片选择组件
    await ImagePickerBottomSheet.show(
      config: const ImagePickerConfig(
        title: '选择活动图片',
        maxWidth: 1080,
        maxHeight: 1080,
        imageQuality: 85,
      ),
      onImageSelected: (imagePath) async {
        // 先添加到本地图片列表
        form.value.activityImages.add(imagePath);
        form.refresh();
        
        LoadingUtil.toast('图片选择成功');  // 🔥 使用 LoadingUtil（轻提示）
        
        // 异步上传图片
        await _uploadActivityImage(imagePath);
      },
      onError: (errorMessage, error) {
        LoadingUtil.error(errorMessage);  // 🔥 使用 LoadingUtil
      },
    );
  }
  
  /// 删除活动图片
  void removeActivityImage(int index) {
    if (index < form.value.activityImages.length) {
      form.value.activityImages.removeAt(index);
      form.refresh();
      LoadingUtil.toast('图片已删除');  // 🔥 使用 LoadingUtil（轻提示）
    }
  }
  
  /// 上传活动图片到服务器
  Future<void> _uploadActivityImage(String imageFilePath) async {
    try {
      isUploadingImage.value = true;
      
      // 获取当前用户
      final currentUser = _userService.currentUserProfile;
      if (currentUser == null) {
        LoadingUtil.error('请先登录');  // 🔥 使用 LoadingUtil
        return;
      }
      
      debugPrint('🚀 开始上传活动图片: $imageFilePath');
      debugPrint('👤 用户ID: ${currentUser.userid}');
      
      // 调用图片上传API
      final result = await UserApi.uploadUserImage(
        userId: currentUser.userid ?? 0,
        imageFilePath: imageFilePath,
      );
      
      if (result.success && result.imgUrl != null) {
        // 上传成功，替换本地路径为网络URL
        final index = form.value.activityImages.indexOf(imageFilePath);
        if (index != -1) {
          form.value.activityImages[index] = result.imgUrl!;
          form.refresh();
        }
        
        LoadingUtil.toast('图片上传成功');  // 🔥 使用 LoadingUtil（轻提示）
        debugPrint('✅ 图片上传成功: ${result.imgUrl}');
      } else {
        LoadingUtil.error(result.errorMessage ?? '图片上传失败');  // 🔥 使用 LoadingUtil
        debugPrint('❌ 图片上传失败: ${result.errorMessage}');
      }
      
    } catch (e) {
      LoadingUtil.error('图片上传失败: ${e.toString()}');  // 🔥 使用 LoadingUtil
      debugPrint('💥 图片上传异常: $e');
    } finally {
      isUploadingImage.value = false;
    }
  }
  
  // ==================== 表单提交 ====================
  
  /// 提交表单
  Future<void> submitForm() async {
    // 验证用户登录状态
    if (_userService.currentUserProfile == null || !_userService.isLoggedIn) {
      LoadingUtil.error('请先登录后再发布活动');  // 🔥 使用 LoadingUtil
      return;
    }
    
    // 表单验证
    if (!form.value.isValid) {
      // 显示第一个验证错误
      final errors = form.value.validationErrors;
      if (errors.isNotEmpty) {
        LoadingUtil.error(errors.values.first);  // 🔥 使用 LoadingUtil
        return;
      }
    }
    
    // 开始加载
    isLoading.value = true;
    
    try {
      final currentUser = _userService.currentUserProfile!;
      
      debugPrint('📝 =============== 开始发布活动 ===============');
      debugPrint('👤 用户ID: ${currentUser.userid}');
      debugPrint('👤 用户名: ${currentUser.username ?? ""}');
      debugPrint('📋 表单数据:\n${form.value}');
      
      // 🔥 显示 Loading
      LoadingUtil.show('发布中...');
      
      // 🔥 使用业务编排服务发布活动（集成权限检查、积分扣除、API调用）
      final orchestrationService = Get.find<BusinessOrchestrationService>();
      
      final result = await orchestrationService.publishActivity(
        activityData: {
          'userId': currentUser.userid,  // 🔥 用户ID（权限检查和积分扣除）
          'activityTitle': form.value.title.trim(),
          'publisherId': currentUser.userid,
          'publisherNickname': currentUser.username ?? '',
          'activityPublishTime': form.value.formatDateTimeForApi(form.value.startDate!),
          'latitude': form.value.latitude,
          'longitude': form.value.longitude,
          'activityDetails': form.value.details.trim(),
          'activityLocation': form.value.location,
          'activityImages': form.value.networkImageUrls,
          'activityType': form.value.activityTypeArray,
          'activityTags': <String>[],
          'activityMaxParticipants': int.parse(form.value.peopleCount),
          'publisherAvatarUrl': currentUser.userAvatarUrl?.isEmpty == false ? currentUser.userAvatarUrl : null,
          'publisherSignature': currentUser.userSignature?.isEmpty == false ? currentUser.userSignature : null,
          'publisherTags': ['新用户'],
          'extraData': {
            'activityEndTime': form.value.formatDateTimeForApi(form.value.endDate!),
            'duration': form.value.calculateDuration(),
          },
        },
        checkPermission: true,  // 🔥 启用权限检查
      );
      
      debugPrint('📬 业务编排结果: $result');
      
      // 🔥 关闭 Loading
      LoadingUtil.dismiss();
      
      // 处理响应
      if (result['status'] == 'success') {
        final pointsChange = (result['pointsChange'] ?? 0) as int;  // 🔥 积分变化
        
        // 显示成功对话框
        _showSuccessDialog(
          message: result['message'] ?? '活动发布成功',
          pointsChange: pointsChange,
        );
        
        debugPrint('✅ 活动发布成功（业务编排）');
      } else {
        LoadingUtil.error(result['message'] ?? '发布失败，请重试');  // 🔥 使用 LoadingUtil
        debugPrint('❌ 活动发布失败: ${result['message']}');
      }
      
    } catch (e) {
      LoadingUtil.dismiss();  // 🔥 确保关闭 Loading
      LoadingUtil.error('发布失败: ${e.toString()}');  // 🔥 使用 LoadingUtil
      debugPrint('💥 发布活动异常: $e');
    } finally {
      isLoading.value = false;
      debugPrint('🏁 =============== 发布活动流程结束 ===============');
    }
  }
  
  /// 显示成功对话框
  void _showSuccessDialog({
    required String message,
    required int pointsChange,
  }) {
    Get.dialog(
      Dialog(
        backgroundColor: Colors.transparent,
        child: Container(
          margin: const EdgeInsets.symmetric(horizontal: 40),
          padding: const EdgeInsets.all(24),
          decoration: BoxDecoration(
            color: Colors.white,
            borderRadius: BorderRadius.circular(16),
            boxShadow: [
              BoxShadow(
                color: Colors.black.withOpacity(0.1),
                blurRadius: 10,
                spreadRadius: 2,
              ),
            ],
          ),
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              // 成功图标
              Container(
                width: 64,
                height: 64,
                decoration: const BoxDecoration(
                  color: Color(0xFF4CAF50),
                  shape: BoxShape.circle,
                ),
                child: const Icon(
                  Icons.check,
                  color: Colors.white,
                  size: 40,
                ),
              ),
              
              const SizedBox(height: 24),
              
              // 标题
              const Text(
                '发布成功！',
                style: TextStyle(
                  fontSize: 20,
                  fontWeight: FontWeight.bold,
                  color: Colors.black87,
                ),
              ),
              
              const SizedBox(height: 12),
              
              // 消息内容
              Text(
                message,
                textAlign: TextAlign.center,
                style: TextStyle(
                  fontSize: 16,
                  color: Colors.grey[600],
                  height: 1.4,
                ),
              ),
              
              if (pointsChange != 0) ...[
                const SizedBox(height: 8),
                Container(
                  padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
                  decoration: BoxDecoration(
                    color: pointsChange > 0 ? Colors.green[50] : Colors.orange[50],
                    borderRadius: BorderRadius.circular(12),
                    border: Border.all(
                      color: pointsChange > 0 ? Colors.green[200]! : Colors.orange[200]!,
                      width: 1,
                    ),
                  ),
                  child: Text(
                    pointsChange > 0 ? '获得积分: +$pointsChange' : '消耗积分: ${pointsChange.abs()}',
                    style: TextStyle(
                      fontSize: 14,
                      color: pointsChange > 0 ? Colors.green[700] : Colors.orange[700],
                      fontWeight: FontWeight.w600,
                    ),
                  ),
                ),
              ],
              
              const SizedBox(height: 32),
              
              // 确认按钮
              SizedBox(
                width: double.infinity,
                height: 44,
                child: ElevatedButton(
                  onPressed: () {
                    Get.back(); // 关闭对话框
                    _clearForm(); // 清空表单
                    
                    // 🎯 跳转到"我的发布"页面（使用 toNamed 保留返回按钮）
                    Get.toNamed(
                      RouteNames.activityMyPublish,
                      arguments: {
                        'switchToSubTab': 0, // 切换到"进行中"子标签
                      },
                    );
                  },
                  style: ElevatedButton.styleFrom(
                    backgroundColor: const Color(0xFFE33641),
                    shape: RoundedRectangleBorder(
                      borderRadius: BorderRadius.circular(8),
                    ),
                    elevation: 0,
                  ),
                  child: const Text(
                    '确定',
                    style: TextStyle(
                      fontSize: 16,
                      fontWeight: FontWeight.w500,
                      color: Colors.white,
                    ),
                  ),
                ),
              ),
            ],
          ),
        ),
      ),
      barrierDismissible: false,
    );
  }
  
  /// 清空表单
  void _clearForm() {
    titleController.clear();
    peopleCountController.clear();
    detailsController.clear();
    form.value.reset();
    form.refresh();
    debugPrint('✅ 表单已清空');
  }
  
  // ==================== 生命周期 ====================

  @override
  void onClose() {
    titleController.dispose();
    peopleCountController.dispose();
    detailsController.dispose();
    
    titleFocusNode.dispose();
    peopleCountFocusNode.dispose();
    detailsFocusNode.dispose();
    
    super.onClose();
  }
}
